#!/usr/bin/env python
# -*- coding: utf-8 -*-
#modulos del sistema
try:
    import pygtk
    pygtk.require("2.0")
    import gtk
    import gtk.glade
    import os
except:
    print "Necesitas la librería gráficas gtk+pygtk"

class ghhp:
    """
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile, "window1")

        dic = {"on_window1_destroy" : gtk.main_quit,
                "on_button4_clicked" : self.registrar_tiket,
                "on_button5_clicked" : self.buscar_tiket,
                "on_button6_clicked" : self.ver_detalle,
                "on_button7_clicked" : self.configurar_reporte,
                "on_button8_clicked" : self.consultar_intervenciones,
                "on_button9_clicked" : self.add_clasif,
                "on_button13_clicked": self.find_clasif,
                "on_button14_clicked": self.edit_clasif,
                "on_button15_clicked": self.list_group,
                "on_button16_clicked": self.add_group,
                "on_button17_clicked": self.find_group,
                "on_button18_clicked": self.view_info_for_tiket,
                "on_button34_clicked": self.create_ticket,
                "on_button49_clicked": self.consult_ticket,
                "on_button55_clicked": self.probando_check,
                "on_button50_clicked": self.consult_intervetion,
                "on_button51_clicked": self.create_clasificacion_ticket,
                "on_button52_clicked": self.find_clasification_ticket}

        self.wTree.signal_autoconnect(dic)

    def create_ticket(self,ticket):
        """
            Probando como mantener ocultos los paneles
        """
        self.w_crear_ticket = create_ticket()
        self.w_crear_ticket.run()

    def consult_ticket(self,widget):
        self.w_consult_ticket = consult_ticket()
        self.w_consult_ticket.run()

    def registrar_tiket(self,widget):
        print "Apretaste el botón 4"
        self.dialog = dialog_registrar_tiket()
        print self.dialog.obs
        self.dialog.run()

    def buscar_tiket(self,widget):
        print "Apretaste el boton buscar"
        self.dialog_2 = dialog_consultar_tiket()
        self.dialog_2.run()
    def ver_detalle(self,widget):
        "Apretaste detalle"
        self.dialog_detalle = dialog_detalle_tiket()
        self.dialog_detalle.run()

    def configurar_reporte(self,widget):
        print "Configurar"
        self.dialog_conf = dialog_configurar_reporte()
        self.dialog_conf.run()
    def consultar_intervenciones(self,widget):
        print "consultar intervenciones"
        self.dialog_inter = dialog_consultar_intervenciones()
        self.dialog_inter.run()
    def add_clasif(self,widget):
        print "add clasificacion"
        self.dialog_add_clasif = dialog_new_clasificacion()
        self.dialog_add_clasif.run()

    def find_clasif(self,widget):
        print "add clasificacion"
        self.dialog_find_clasif = dialog_find_clasif()
        self.dialog_find_clasif.run()

    def edit_clasif(self,widget):
        print "add clasificacion"
        self.dialog_edit_clasif = dialog_edit_clasif()
        self.dialog_edit_clasif.run()

    def list_group(self,widget):
        print "add clasificacion"
        self.dialog_list_group = dialog_list_group()
        self.dialog_list_group.run()

    def add_group(self,widget):
        print "add clasificacion"
        self.dialog_add_group = dialog_add_group()
        self.dialog_add_group.run()

    def find_group(self,widget):
        print "find group"
        self.dialog_find_group = find_group_resolution()
        #self.dialog_find_group.run()

    def view_info_for_tiket(self,widget):
        print "view info for tiket"
        self.dialog_info_for_tiket = dialog_info_for_tiket()
        self.dialog_info_for_tiket.run()
    def probando_check(self,widget):
        print "probando check"
        self.probando = probando_check()
    def consult_intervetion(self,widget):
        self.dialog_consult_intervetion = consult_intervention()
    def create_clasificacion_ticket(self,widget):
        self.dialog_create_clasificacion_ticket = create_clasificacion_ticket()
    def find_clasification_ticket(self,widget):
        self.dialog_clasification_ticket = find_clasification_ticket()

"""
    CLASS: create_ticket!
"""
class create_ticket:
    """
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"create_ticket")
        self.hbox_62 = self.wTree.get_widget("hbox62")
        self.hbox_65 = self.wTree.get_widget("hbox65")
        self.hbox_64 = self.wTree.get_widget("hbox64")
        self.hbox_156 = self.wTree.get_widget("hbox156")
        self.wTree.get_widget("label_numero_ticket").set_text('0021')
        self.un_dict={"on_button37_clicked": self.validate,
                "on_button38_clicked": self.close,
                "on_button41_clicked": self.validate_dos,
                "on_button40_clicked": self.close}

        self.wTree.signal_autoconnect(self.un_dict)
    def run(self):
        self.w_create_ticket = self.wTree.get_widget("create_ticket")
        #gtk.main()

    def validate(self,widget):
        """
            Se dedica a tomar el hbox62 y comprobar todos lo campos
            obligatorios, y de ser necesario se mostrará el hbox 64 y el
            hbox65.
        """
        print "Entré a validar"
        print self.wTree.get_widget("entry70").get_text()
        if (self.wTree.get_widget("entry70").get_text()=='11122'):
            self.hbox_62.hide()
            """
                Se deben tomar los datos del hbox62 y colocarlos en el hbox64
            """
            apellido=self.wTree.get_widget("entry71").get_text()
            nombre=self.wTree.get_widget("entry72").get_text()
            codigo=self.wTree.get_widget("entry73").get_text()
            nombre_clasif=self.wTree.get_widget("entry74").get_text()
            descripcion=self.wTree.get_widget("textview6").get_buffer()

            start = descripcion.get_start_iter()
            end = descripcion.get_end_iter()
            texto_descripcion = descripcion.get_text(start,end)

            self.wTree.get_widget("legajo_cliente").set_text('1122')
            self.wTree.get_widget("apellido_cliente").set_text(apellido)
            self.wTree.get_widget("nombre_cliente").set_text(nombre)
            self.wTree.get_widget("codigo_clasificacion").set_text(codigo)
            self.wTree.get_widget("nombre_clasificacion").set_text(nombre_clasif)
            self.wTree.get_widget("numero_ticket").set_text('09')
            self.wTree.get_widget("descripcion_problema").set_text(texto_descripcion)

            self.hbox_65.show()
            self.hbox_64.show()

    def validate_dos(self,widget):
        """
            Tenemos que validar observacion y ademas hacer hbox49 show()
            que ahí se encuentra la informacion de los grupos de resolucion.
            Datos necesarios para la derivacion de ticket.
            DERIVAR TICKET
        """
        self.wTree.get_widget("vbox49").show()
        self.hbox_156.hide()

    def close(self,widget):
        print "Close"
        pass

"""
    Class consultar ticket
"""
class consult_ticket:
    """
        CDU 02
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"consult_ticket")
        self.hbox_79 = self.wTree.get_widget("hbox79")
        self.hbox_81 = self.wTree.get_widget("hbox81")
        self.hbox_97 = self.wTree.get_widget("hbox97")
        self.vbox_51 = self.wTree.get_widget("vbox51")
        # Creamos las cabecera de la lista de búsqueda
        self.find_view = self.wTree.get_widget("treeview14")
        #print self.find_view
        self.add_find_column("Numero", 0)
        self.add_find_column("Legajo", 1)
        self.add_find_column("Fecha\napertura", 2)
        self.add_find_column("Hora\napertura", 3)
        self.add_find_column("Operador que\ncreo el ticket",4)
        self.add_find_column("Clasificacion\nactual",5)
        self.add_find_column("Estado\nactual",6)
        self.add_find_column("Fecha último\ncambio estado",7)
        self.add_find_column("Grupo Resolucion\nactual asignado",8)
        self.find_list = gtk.ListStore(str, str, str, str, str, str, str, str,
                str)
        self.find_view.set_model(self.find_list)
        self.un_dict = {"on_button99_clicked" : self.find,
                "on_button100_clicked" : self.cleane,
                "on_button101_clicked" : self.close,
                "on_button45_clicked" : self.derive,
                "on_button46_clicked" : self.close_ticket,
                "on_button47_clicked" : self.view_all_info_ticket,
                "on_button57_clicked" : self.config_report}
        self.wTree.signal_autoconnect(self.un_dict)

    def run(self):
        self.w_create_ticket = self.wTree.get_widget("consult_ticket")

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

    def find(self,widget):
        """
        """
        # Info Client
        legajo = self.wTree.get_widget("entry80").get_text()
        apellido = self.wTree.get_widget("entry81").get_text()
        nombre = self.wTree.get_widget("entry82").get_text()
        # Info ticket
        number_ticket = self.wTree.get_widget("entry86").get_text()
        clasif_ticket = 'Todas'#wTree.get_widget("comboboxentry22").get_text()
        estado_ticket = 'Abierto en mesa de ayuda'
        # Ultimo grupo de resolucion asignado
        last_group = 'Todos'#wTree.get_widget("entry86").get_text()
        # Fecha
        fecha_apertuda_desde = '---'
        fecha_apertura_hasta = '---'
        fecha_ultimo_cambio_desde = '---'
        fecha_ultimo_cambio_hasta = '---'

        # seteamos
        # Info Client
        self.wTree.get_widget("legajo_cliente").set_text(legajo)
        self.wTree.get_widget("apellido_cliente").set_text(apellido)
        self.wTree.get_widget("nombre_cliente").set_text(nombre)
        # Info Ticket
        self.wTree.get_widget("numero_ticket").set_text('12456')
        self.wTree.get_widget("clasificacion_ticket").set_text(clasif_ticket)
        self.wTree.get_widget("estado_ticket").set_text(estado_ticket)
        # Ultimo grupo de resolucion
        self.wTree.get_widget("ultimo_grupo_resolucion").set_text(last_group)
        # Fecha
        self.wTree.get_widget("fecha_de_apertura").set_text('---')
        self.wTree.get_widget("fecha_de_ultimo_cambio").set_text('---')

        self.vbox_51.hide()
        self.hbox_97.show()
        self.hbox_79.show()
        lista=['12456',
                legajo,
                '12-09-2007',
                '15:20',
                'Mesa de Ayuda',
                'Mal funcionamiento de Hardware',
                'Abierto en Mesa de Ayuda',
                '12-09-2007',
                'No tiene']
        self.find_list.append(lista)
    def derive(self,widget):
        """
            call CDU04
        """
        #self.hbox_81.show()

    def close(self,widget):
        pass
    def cleane(self,widget):
        pass
    def close_ticket(self,widget):
        pass
    def view_all_info_ticket(self,widget):
        """
            Creamos una instancia de dialog_detalle_ticket
        """
        print "Details of tickets"
        self.dialog_detalle_ticket = dialog_all_info_ticket()
        pass
    def config_report(self,widget):
        print "Config Report"
        self.config_report = config_report()

"""
    Class DIALOG DETALLE TICKET CDU02 - Consultar Ticket
"""
class dialog_all_info_ticket:
    """
        Extend CDU02
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_detalle_ticket")

        #Generamos la vista del resultado
        self.find_view = self.wTree.get_widget("treeview15")
        #print self.find_view
        self.add_find_column("Fecha de cambio\nde estado", 0)
        self.add_find_column("Hora de cambio\nde estado", 1)
        self.add_find_column("Operador que\ncambio el estado", 2)
        self.add_find_column("Estado", 3)
        self.add_find_column("Grupo de resolución",4)
        self.add_find_column("Clasificación",5)
        self.find_list = gtk.ListStore(str, str, str, str, str, str)
        self.find_view.set_model(self.find_list)
        self.find_list.append(['--','--','--','--','--','--'])
        self.find_list.append(['--','--','--','--','--','--'])

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class config_report:
    """
        CDU05 extend CDU02
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"config_report")
        self.hbox_108 = self.wTree.get_widget("hbox108")
        self.hbox_110 = self.wTree.get_widget("hbox110")
        self.hbox_116 = self.wTree.get_widget("hbox116")
        self.hbox_118 = self.wTree.get_widget("hbox118")
        self.vbox_65 = self.wTree.get_widget("vbox65")
        self.hbox_119 = self.wTree.get_widget("hbox119")
        self.hbox_152 = self.wTree.get_widget("hbox152")
        self.un_dict = {"on_button62_clicked" : self.view_info,
                "on_button63_clicked" : self.close,
                "on_button64_clicked" : self.view_details_history,
                "on_checkbutton13_toggled": self.ver_secuencia}

        self.wTree.signal_autoconnect(self.un_dict)
        # Generamos la vista del resultado
        self.find_view= self.wTree.get_widget("treeview16")
        ##################################################################
        # Columnas para el caso de uso 20
        #######
        #self.find_view.append_column(self.add_find_column("Nro.\nticket",0))
        #self.find_view.append_column(self.add_find_column("Clasificación\nactual",1))
        #self.find_view.append_column(self.add_find_column("Estado\nactual",2))
        #self.find_view.append_column(self.add_find_column("Tiempo acumulado\nde atención",3))
        #self.find_view.append_column(self.add_find_column("Grupo de\nresolución",4))
        #self.find_view.append_column(self.add_find_column("Tiempo real\nde atención",5))
        #self.find_view.append_column(self.add_find_column("Tiempo total\nasignado",6))
        #self.find_view.append_column(self.add_find_column("Reclasificaciones",7))
        #self.find_view.append_column(self.add_find_column("Fecha de\nreclasificación",8))
        
        ###################################################################
        # Columnas para el caso de uso 21
        #####
        #self.find_view.append_column(self.add_find_column("Cant.\nticket",0))
        #self.find_view.append_column(self.add_find_column("Nro.\nticket",0))
        #self.find_view.append_column(self.add_find_column("Clasificación\nactual",1))
        #self.find_view.append_column(self.add_find_column("Estado\nactual",2))
        #self.find_view.append_column(self.add_find_column("Fecha de\napertura",3))
        #self.find_view.append_column(self.add_find_column("Fecha de último\ncambio de estado",4))
        #self.find_view.append_column(self.add_find_column("Último grupo\nde resolución",5))
        #self.find_view.append_column(self.add_find_column("Última\nObservación",6))
        
        #########################################################################
        # Columnas para el caso de uso 22
        #########
        #self.find_view.append_column(self.add_find_column("Nro.\nticket",0))
        #self.find_view.append_column(self.add_find_column("Nro.\nlegajo",1))
        #self.find_view.append_column(self.add_find_column("Clasificación\nactual",2))
        #self.find_view.append_column(self.add_find_column("Fecha de\napertura",3))
        #self.find_view.append_column(self.add_find_column("Tiempo acumulado\nde atención",4))
        #self.find_view.append_column(self.add_find_column("Último grupo\nde resolución",5))
        
        #####################################################################
        # Columnas para el caso de uso 23
        ############
        #self.find_view.append_column(self.add_find_column("Nro.\nticket",0))
        #self.find_view.append_column(self.add_find_column("Clasificación\nactual",1))
        #self.find_view.append_column(self.add_find_column("Estado\nactual",2))
        #self.find_view.append_column(self.add_find_column("Fecha de\napertura",3))
        #self.find_view.append_column(self.add_find_column("Estado de la\nintervención en\nel grupo",4))
        #self.find_view.append_column(self.add_find_column("Tiempo real\nde atención",5))
        #self.find_view.append_column(self.add_find_column("Tiempo total\nasignado",6))
        #self.find_view.append_column(self.add_find_column("Observaciones\nreg. por el grupo\npara el ticket",7))
        
        ########################################################################
        # Columnas para el caso de uso 24
        ###############
        self.find_view.append_column(self.add_find_column("Nro.\nticket",0))
        self.find_view.append_column(self.add_find_column("Nro.\nlegajo",1))
        self.find_view.append_column(self.add_find_column("Estado\nactual",2))
        self.find_view.append_column(self.add_find_column("Fecha de\napertura",3))
        self.find_view.append_column(self.add_find_column("Último grupo\nde resolución",4))

        lista_a = gtk.ListStore(str)
        lista_b = gtk.ListStore(str)
        
        arbol_a = self.wTree.get_widget("treeview29")
        arbol_a.append_column(self.add_find_column("Nombre",0))
        
        arbol_b = self.wTree.get_widget("treeview30")
        arbol_b.append_column(self.add_find_column("Nombre",0))

        arbol_a.set_model(lista_a)
        arbol_b.set_model(lista_b)

        lista_b.append(['Nro. de Tiket'])
        lista_a.append(['Legajo'])
        lista_b.append(['Fecha de apertura'])
        lista_a.append(['Estado actual de ticket'])
        lista_a.append(['Grupo actual de resolucion'])

        ###############################################################
        self.find_result=gtk.ListStore(str,str,str,str,str)
        self.find_view.set_model(self.find_result)
        self.find_view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_HORIZONTAL)
        self.selection = self.find_view.get_selection()
        self.selection.connect("changed", self.display_selected_user)
    
    def display_selected_user(self,*args):
        model, paths = self.selection.get_selected_rows()
        if paths:
            # Habilitamos el hbox de la info de usuario
            print "Selected user"
            self.hbox_119.show()
            self.wTree.get_widget("un_legajo").set_text('1512')
            print "Paths"
            print paths[0]
            print "Model"
            print model

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        return column

    def view_legajo(self,widget):
        self.hbox_108.hide()
        self.hbox_116.show()
        
   
    def ver_secuencia(self,widget):
        print "llego"
        self.hbox_118.show()
        self.vbox_65.show()

    def view_info(self,widget):
        """
            Nota: de acuerdo a lo elegido en los radiobutton es hacia que CDU
            iremos.
        """
        print "view_info"
        self.hbox_108.hide()
        self.hbox_110.show()
        self.hbox_116.hide()
        # probando
        lista =['1122',
                '12564',
                'Solucionado a la espera Ok.',
                '04-05-2007',
                'Mesa de Ayuda']
        lista_2 =['1122',
                '12458',
                'Cerrado',
                '08-11-2007',
                'un_grupo']
        
        self.find_result.append(lista)
        self.find_result.append(lista_2)
        self.wTree.get_widget("cantidad_ticket").set_text('2')
    def close(self,widget):
        pass
    def view_details_history(self,widget):
        """
           Solo mostramos los 20 primeros caracteres del historial
        """
        self.dialog_history_ticket = dialog_all_info_history_ticket()
        lista=['Mesa de Ayuda',
                '1:15 hs',
                '2:30 hs',
                'Abierto en Mesa de ayuda',
                '2007-09-02']
        lista_2=['Grupo_uno',
                '2 días 1:25hs',
                '3 días',
                'Solucionado a la Espera OK.',
                '2007-09-05']
        self.dialog_history_ticket.find_list.append(lista)
        self.dialog_history_ticket.find_list.append(lista_2)
"""
    CDU-20 Ver historial del ticket
"""
class dialog_all_info_history_ticket:
    """
        Extend CDU02
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_detalle_ticket")

        #Generamos la vista del resultado
        self.find_view = self.wTree.get_widget("treeview15")
        #print self.find_view
        self.add_find_column("Grupo de\nResolución", 0)
        self.add_find_column("Tiempo Real\nde atención", 1)
        self.add_find_column("Tiempo Total\nasignado", 2)
        self.add_find_column("Clasificación", 3)
        self.add_find_column("Fecha",4)
        self.find_list = gtk.ListStore(str, str, str, str, str)
        self.find_view.set_model(self.find_list)
        self.find_view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_HORIZONTAL)
    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class consult_intervention:
    """
        CDU-07
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"consult_intervention")
        self.hbox_120 = self.wTree.get_widget("hbox120")
        self.hbox_121 = self.wTree.get_widget("hbox121")
        self.find_view = self.wTree.get_widget("treeview17")
        #print self.find_view
        self.add_find_column("Ticket", 0)
        self.add_find_column("Legajo",1)
        self.add_find_column("Clasificacion actual\ndel ticket", 2)
        self.add_find_column("Estado\ntikect", 3)
        self.add_find_column("Fecha de\napertura", 4)
        self.add_find_column("Estado\nintervencion",5)
        self.add_find_column("Fecha de asignacion\nal grupo",6)
        self.add_find_column("Grupo de\nresolucion",7)
        self.add_find_column("Observaciones de la\n intervencion",8)
        self.find_list = gtk.ListStore(str, str, str, str, str, str, str,str,str)
        self.find_view.set_model(self.find_list)

        self.un_dict={"on_button68_clicked": self.find_intervention,
                "on_button69_clicked": self.cleane,
                "on_button70_clicked": self.cancel,
                "on_button71_clicked": self.edit_estado_intervention,
                "on_button72_clicked": self.add_comment}
        self.wTree.signal_autoconnect(self.un_dict)
    
    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

    def find_intervention(self,widget):
        """
        """
        print "Find Intervention"
        self.hbox_120.hide()
        self.hbox_121.show()
        
        lista=['1144',
                '12456',
                'Problemas\ncuenta\ncorreo',
                'Abierto\nderivado',
                '02-05-2007',
                'Es espera',
                '04-05-2007',
                'Grupo_Uno',
                'La intervención esta en\nespera por no poder\nhabilitar la\n clave de acceso']
        lista_2=['1044',
                '45612',
                'Problemas CPU',
                'Cerrado',
                '02-05-2007',
                'Solucionada a\nla espera Ok.',
                '04-05-2007',
                'Grupo_Uno',
                'La intervención esta\nsolucionada,hay que\nderivarla a mesa de ayuda']

        self.find_list.append(lista)
        self.find_list.append(lista_2)
    def cleane(seld,widget):
        """
        """
        pass
    def cancel(self,widget):
        """
        """
        pass
    def edit_comment(self,widget):
        pass
    def add_comment(self,widget):
        pass
    def edit_estado_intervention(self,widget):
        pass

class create_clasificacion_ticket:
    """
        Crear Clasificacion ticket CDU 10
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"create_clasif_ticket")
        self.hbox_127 = self.wTree.get_widget("hbox127")
        self.hbox_128 = self.wTree.get_widget("hbox128")
        print self.hbox_127
        print self.hbox_128

        self.un_dict = {"on_button76_clicked": self.create_clasificacion_ticket,
                "on_button84_clicked": self.close,
                "on_button80_clicked": self.add_group_to_list,
                "on_button83_clicked": self.quit_group_to_list,
                "on_button81_clicked": self.accept,
                "on_button82_clicked": self.close_1}

        self.wTree.signal_autoconnect(self.un_dict)
        # Generamos la visda del treeview clasificaciones existentes
        self.clasif_exist = self.wTree.get_widget("treeview19")
        self.clasif_exist.append_column(self.add_find_column("Código",0))
        self.clasif_exist.append_column(self.add_find_column("Nombre",1))
        self.clasif_exist_list = gtk.ListStore(str, str)
        self.clasif_exist.set_model(self.clasif_exist_list)

        # Generamos la vista del treeview grupos asociados
        self.group = self.wTree.get_widget("treeview18")
        self.group.append_column(self.add_find_column("Código",0))
        self.group.append_column(self.add_find_column("Nombre",1))
        self.group_list = gtk.ListStore(str, str)
        self.group.set_model(self.group_list)

        lista=['1','Problemas de CPU']
        lista_2=[2,'Cambios de Configuración de SO.']
        lista_3=[3,'Soliciud de instalaciones']
        self.clasif_exist_list.append(lista)
        self.clasif_exist_list.append(lista_2)
        self.clasif_exist_list.append(lista_3)

    def create_clasificacion_ticket(self,widget):
        print "Create clasificacion"
        self.hbox_127.hide()
        self.hbox_128.show()

    def close(self,widget):
        print "Cancel"
    def close_1(self,widget):
        pass

    def add_group_to_list(self,widget):
        print "Add group"

    def quit_group_to_list(self,widget):
        print "Quit group"

    def accept(self,widget):
        pass

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        return column

class find_clasification_ticket:
    """
        CDU-11
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"find_clasification_ticket")
        self.hbox_132 = self.wTree.get_widget("hbox132")
        self.hbox_133 = self.wTree.get_widget("hbox133")

        self.find_view = self.wTree.get_widget("treeview21")
        #print self.find_view
        self.add_find_column("Código", 0)
        self.add_find_column("Nombre",1)
        self.add_find_column("Estado", 2)
        self.add_find_column("Descripción",3)
        self.find_list = gtk.ListStore(str, str, str, str)
        self.find_view.set_model(self.find_list)

        self.un_dict={"on_button85_clicked": self.find_clasification,
                "on_button86_clicked": self.cleane,
                "on_button92_clicked": self.cancel,
                "on_button87_clicked": self.view_all_details,
                "on_button88_clicked": self.edit_clasification,
                "on_button89_clicked": self.delete_clasification,
                "on_button90_clicked": self.accept,
                "on_button91_clicked": self.cancel}
        self.wTree.signal_autoconnect(self.un_dict)

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

    def find_clasification(self,widget):
        print "Finf Clasification"
        self.hbox_132.hide()
        self.hbox_133.show()
        lista=['1','Problemas de CPU','Activa','No se pueden detectardispositivos']
        lista_2=[2,'Cambios de Configuración de SO.','Activa',
            'Actualizaciones del SO ']
        lista_3=[3,'Soliciud de instalaciones',
                'Inactiva','Instalación de nuevo software']
        self.find_list.append(lista)
        self.find_list.append(lista_2)
        self.find_list.append(lista_3)
        
    def cleane(self,widget):
        pass
    def cancel(self,widget):
        pass
    def view_all_details(self,widget):
        print "View all datails"
        self.dialod_details = view_details_clasification_ticket()
    def edit_clasification(self,widget):
        print "Edit clasification"
        self.dialog_edit_clasification = edit_clasification_ticket()
    def delete_clasification(self,widget):
        pass
    def accept(self,widget):
        pass

class edit_clasification_ticket:
    """
        extend CDU11 --> CDU12
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"edit_clasification_ticket")
        self.hbox_138 = self.wTree.get_widget("hbox138")
        self.hbox_139 = self.wTree.get_widget("hbox139")
        
        self.un_dict = {"on_button93_clicked": self.edit_clasification_ticket,
                "on_button94_clicked": self.close,
                "on_button95_clicked": self.add_group_to_list,
                "on_button96_clicked": self.quit_group_to_list,
                "on_button97_clicked": self.accept,
                "on_button98_clicked": self.close}

        self.wTree.signal_autoconnect(self.un_dict)
        # Generamos la visda del treeview clasificaciones existentes
        self.clasif_exist = self.wTree.get_widget("treeview23")
        self.clasif_exist.append_column(self.add_find_column("Código",0))
        self.clasif_exist.append_column(self.add_find_column("Nombre",1))
        self.clasif_exist_list = gtk.ListStore(str, str)
        self.clasif_exist.set_model(self.clasif_exist_list)

        # Generamos la vista del treeview grupos asociados
        self.group = self.wTree.get_widget("treeview24")
        self.group.append_column(self.add_find_column("Código",0))
        self.group.append_column(self.add_find_column("Nombre",1))
        self.group_list = gtk.ListStore(str, str)
        self.group.set_model(self.group_list)

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        return column
    
    def edit_clasification_ticket(self,widget):
        print "Edit Clasification ticket"
        self.hbox_138.hide()
        self.hbox_139.show()
    def close(self,widget):
        pass
    def add_group_to_list(self,widget):
        pass
    def quit_group_to_list(self,widget):
        pass
    def close(self,widget):
        pass
    def accept(self,widget):
        pass

class view_details_clasification_ticket:
    """
        extend CDU -11
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"view_details_clasification_ticket")
        self.find_view = self.wTree.get_widget("treeview22")
        #print self.find_view
        self.add_find_column("Número", 0)
        self.add_find_column("Legajo\nUsuario",1)
        self.add_find_column("Apellido y\nNombre", 2)
        self.add_find_column("Tel.\nInterno",3)
        self.add_find_column("Tel.\nDirecto",4)
        self.add_find_column("Fecha de\nderivación",5)
        self.add_find_column("Hora de\nderivación",6)
        self.add_find_column("Estado de la\nintercención",7)
        self.find_list = gtk.ListStore(str, str, str, str, str, str, str, str)
        self.find_view.set_model(self.find_list)
    
    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class find_group_resolution:
    """
        CDU-14
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"find_group_resolution")
        self.hbox_142 = self.wTree.get_widget("hbox142")
        self.hbox_143 = self.wTree.get_widget("hbox143")

        self.un_dict = {"on_button102_clicked": self.find_group_resolution,
                "on_button103_clicked": self.cleane,
                "on_button104_clicked": self.cancel,
                "on_button105_clicked": self.view_details_group_resolution,
                "on_button106_clicked": self.edit_group_resolution,
                "on_button107_clicked": self.delete_group_resolution,
                "on_button108_clicked": self.accept,
                "on_button109_clicked": self.cancel}

        self.wTree.signal_autoconnect(self.un_dict)
        
        self.find_view= self.wTree.get_widget("treeview26")
        self.add_find_column("Codigo",0)
        self.add_find_column("Nombre",1)
        self.add_find_column("Estado",2)
        self.find_result = gtk.ListStore(str,str,str)
        self.find_view.set_model(self.find_result)
        
        lista=['1','Grupo_uno','Activo']
        lista_2=['2','Grupo_dos','Activo']
        lista_3=['3','Grupo_cuatro','Activo']
        self.find_result.append(lista)
        self.find_result.append(lista_2)
        self.find_result.append(lista_3)

    def find_group_resolution(self,widget):
        print "Find Group Resolution"
        self.hbox_142.hide()
        self.hbox_143.show()

    def cleane(self,widget):
        pass
    def cancel(self,widget):
        pass
    def view_details_group_resolution(self,widget):
        self.dialog_view_details_group_resolution = view_details_group_resolution()
    def edit_group_resolution(self,widget):
        pass
    def delete_group_resolution(self,widget):
        pass
    def accept(self,widget):
        pass

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class view_details_group_resolution:
    """
        extends CDU14
    """
    def __init__(self):
        self.gladefile="ghhp.glade"
        self.wTree=gtk.glade.XML(self.gladefile,"view_details_group_resolution")
        
        # Generamos la visda del treeview clasificaciones existentes
        self.clasif_exist = self.wTree.get_widget("treeview27")
        self.clasif_exist.append_column(self.add_find_column("Legajo",0))
        self.clasif_exist.append_column(self.add_find_column("Apellido",1))
        self.clasif_exist.append_column(self.add_find_column("Nombre",2))
        self.clasif_exist_list = gtk.ListStore(str, str, str)
        self.clasif_exist.set_model(self.clasif_exist_list)

        # Generamos la vista del treeview grupos asociados
        self.group = self.wTree.get_widget("treeview28")
        self.group.append_column(self.add_find_column("Número",0))
        self.group.append_column(self.add_find_column("Legajo\nUsuario",1))
        self.group.append_column(self.add_find_column("Apellido\nNombre",2))
        self.group.append_column(self.add_find_column("Tel.\nInterno",3))
        self.group.append_column(self.add_find_column("Tel.\nDirecto",4))
        self.group.append_column(self.add_find_column("Fecha de\nderivación",5))
        self.group.append_column(self.add_find_column("Hora de \nderivación",6))
        self.group.append_column(self.add_find_column("Estado\nintervención",7))
        self.group_list = gtk.ListStore(str, str, str, str, str, str, str, str)
        self.group.set_model(self.group_list)

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        return column
    


class probando_check:
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"window2")
        self.check_button_1 = self.wTree.get_widget("checkbutton11")
        self.check_button_2 = self.wTree.get_widget("checkbutton12")
        self.hbox_115 = self.wTree.get_widget("hbox115")
        un_dict ={"on_checkbutton11_toggled": self.apreta,
                "on_checkbutton12_toggled": self.locomalo}
        self.wTree.signal_autoconnect(un_dict)
    def apreta(self,widget):
        print 'apreta'
        self.hbox_115.show()
        print self.wTree.get_widget("spinbutton1").get_value()

    def locomalo(self,widget):
        print 'locomalo'
"""
###############################################################################
#
#               VERSION 1.0 LO QUE CUENTA ES LO DE ARRIBA :D
#
################################################################################
"""
class dialog_registrar_tiket:
    """
    """
    def __init__(self):
        #Set the Glade file
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile, "dialog1_registrar_tiket")
        self.obs = self.wTree.get_widget("textview2")
    def run(self):
        self.dlg = self.wTree.get_widget("dialog1_registrar_tiket")


class dialog_consultar_tiket():
    """
    """
    def __init__(self):
        """
        """
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog2_consultar_tiket")
        #Generamos la vista del resultado
        self.find_view = self.wTree.get_widget("treeview1")
        #print self.find_view
        self.add_find_column("Numero", 0)
        self.add_find_column("Legajo", 1)
        self.add_find_column("Fecha apertura", 2)
        self.add_find_column("Hora apertura", 3)
        self.add_find_column("Usuario",4)
        self.add_find_column("Clasificacion",5)
        self.add_find_column("Estado",6)
        self.add_find_column("Fecha ultimo cambio",7)
        self.add_find_column("Grupo de Resolucion asignado",8)
        self.find_list = gtk.ListStore(str, str, str, str, str, str, str, str,
                str)
        self.find_view.set_model(self.find_list)

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)


    def run(self):
        self.dlg_2 = self.wTree.get_widget("dialog2_consultar_tiket")

class dialog_detalle_tiket:
    """
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_detalle_tiket")
        #Generamos la vista del resultado
        self.find_view = self.wTree.get_widget("treeview2")
        #print self.find_view
        self.add_find_column("Fecha", 0)
        self.add_find_column("Hora",1)
        self.add_find_column("Operador que cambio el estado", 2)
        self.add_find_column("Grupo de resolucion", 3)
        self.add_find_column("Observaciones", 4)
        self.add_find_column("Clasificacion",5)
        self.find_list = gtk.ListStore(str, str, str, str, str)
        self.find_view.set_model(self.find_list)

    def run(self):
        self.dialog_detalle=self.wTree.get_widget("dialog_detalle_tiket")
    
    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class dialog_configurar_reporte:
    """
    """
    def __init__(self):
        """
        """
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_configurar_reporte")
    def run(self):
        self.dialog_conf_reporte=self.wTree.get_widget("dialog_configurar_reporte")

class dialog_consultar_intervenciones:
    """
    """
    def __init__(self):
        """
        """
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_consultar_intervenciones")
         #Generamos la vista del resultado
        self.find_view = self.wTree.get_widget("treeview3")
        #print self.find_view
        self.add_find_column("Ticket #", 0)
        self.add_find_column("Legajo #",1)
        self.add_find_column("Clasificacion actual\n del ticket", 2)
        self.add_find_column("Estado\n tikect", 3)
        self.add_find_column("Fecha de\n apertura", 4)
        self.add_find_column("Estado\n intervencion",5)
        self.add_find_column("Fecha de asignacion\n al grupo",6)
        self.add_find_column("Grupo de\n resolucion",7)
        self.add_find_column("Observaciones de la \n intervencion",8)
        self.find_list = gtk.ListStore(str, str, str, str, str, str, str, str)
        self.find_view.set_model(self.find_list)

    def run(self):
        self.dialog_inter = self.wTree.get_widget("dialog_consultar_intervenciones")

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class dialog_new_clasificacion:
    """
    """
    def __init__(self):
        """
        """
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_new_clasif")
        # Clasificacines existentes:
        self.clasificaciones_exist= wTree.get_widget("treeview4")
        self.add_find_column("Codigo #",0)
        self.add_find_column("Nombre",1)
        sef.clas_exist = gtk.ListStore(str,str)
        self.clasificaciones_exist.set_model(self.clas_exist)
        # Seleccionar grupo de resolucion:
        self.list_group_resol = wTree.get_widget("treeview5")
        self.add_find_column("Codigo #",0)
        self.add_find_column("Nombre",1)
        sef.grup_exist = gtk.ListStore(str,str)
        self.list_group_resol.set_model(self.grup_exist)

    def run(self):
        self.dialog_add_clas = self.wTree.get_widget("dialog_nuew_clasif")

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class dialog_find_clasif:
    """
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_find_clasif")
        # Clasificacines existentes:
        self.find_view= self.wTree.get_widget("treeview6")
        self.add_find_column("Codigo #",0)
        self.add_find_column("Nombre",1)
        self.add_find_column("Estado",2)
        self.add_find_column("Descripcion",3)
        self.find_result = gtk.ListStore(str,str,str,str)
        self.find_view.set_model(self.find_result)

    def run(self):
        self.dialog_find_clasif = self.wTree.get_widget("dialog_find_clasif")

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class dialog_edit_clasif:
    """
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_edit_clasif")
        # Clasificacines existentes:
        self.find_view= self.wTree.get_widget("treeview7")
        self.add_find_column("Codigo #",0)
        self.add_find_column("Nombre",1)
        self.find_result = gtk.ListStore(str,str)
        self.find_view.set_model(self.find_result)

    def run(self):
        self.dialog_edit_clasif = self.wTree.get_widget("dialog_edit_clasif")

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class dialog_list_group:
    """
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_list_group")
        # Clasificacines existentes:
        self.find_view= self.wTree.get_widget("treeview8")
        self.add_find_column("Codigo #",0)
        self.add_find_column("Nombre",1)
        self.find_result = gtk.ListStore(str,str)
        self.find_view.set_model(self.find_result)

    def run(self):
        self.dialog_edit_clasif = self.wTree.get_widget("dialog_list_group")

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class dialog_add_group:
    """
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_add_group")
        # Integrantes en el nuevo grupo:
        self.find_view= self.wTree.get_widget("treeview11")
        self.find_view.append_column(self.add_find_column("Legajo",0))
        self.find_view.append_column(self.add_find_column("Apellido",1))
        self.find_view.append_column(self.add_find_column("Nombre",2))
        self.find_result = gtk.ListStore(str,str,str)
        self.find_view.set_model(self.find_result)
        # Grupos existentes:
        self.find_view_2= self.wTree.get_widget("treeview25")
        self.find_view_2.append_column(self.add_find_column("Código",0))
        self.find_view_2.append_column(self.add_find_column("Nombre",1))
        self.find_result_2 = gtk.ListStore(str,str)
        self.find_view_2.set_model(self.find_result_2)
        
        lista=['1','Grupo_uno']
        lista_2=['2','Grupo_dos']
        lista_3=['3','Grupo_cuatro']
        self.find_result_2.append(lista)
        self.find_result_2.append(lista_2)
        self.find_result_2.append(lista_3)

    def run(self):
        self.dialog_edit_clasif = self.wTree.get_widget("dialog_add_group")

    """
       Deberiamos retortar la columna
    """
    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        return column
        #self.find_view.append_column(column)

class dialog_find_group:
    """
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_find_group")
        # Clasificacines existentes:
        self.find_view= self.wTree.get_widget("treeview12")
        self.add_find_column("Codigo",0)
        self.add_find_column("Nombre",1)
        self.add_find_column("Estado",2)
        self.find_result = gtk.ListStore(str,str,str)
        self.find_view.set_model(self.find_result)

        lista=['1','Grupo_uno']
        lista_2=['2','Grupo_dos']
        lista_3=['3','Grupo_cuatro']
        self.find_result.append(lista)
        self.find_result.append(lista_2)
        self.find_result.append(lista_3)

    def run(self):
        self.dialog_find_clasif = self.wTree.get_widget("dialog_find_group")

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

class dialog_info_for_tiket:
    """
    """
    def __init__(self):
        self.gladefile = "ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile,"dialog_info_for_tiket")
        # Clasificacines existentes:
        self.find_view= self.wTree.get_widget("treeview13")
        self.add_find_column("Codigo #",0)
        self.add_find_column("Legajo\n Usuario",1)
        self.add_find_column("Apellido\n Nombre",2)
        self.add_find_column("Telefono\n Interno",3)
        self.add_find_column("Telefono\n Directo",4)
        self.add_find_column("Descripcion\n del Cargo",5)
        self.add_find_column("Ubicacion",6)
        self.add_find_column("Estado\n Ticket",7)
        self.add_find_column("Clasificacion\n",8)
        self.add_find_column("Tiempo de\n atencion",9)
        self.add_find_column("Historial",10)
        self.find_result = gtk.ListStore(str,str,str,str,str,str,str,str,str)
        self.find_view.set_model(self.find_result)

    def run(self):
        self.dialog_find_clasif = self.wTree.get_widget("dialog_find_group")

    def add_find_column(self,title,columnId):
        """
            Esta funcion agrega una columna al resultado de la búsqueda
        """
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(),\
                text=columnId)
        column.set_resizable(True)
        column.set_sort_column_id(columnId)
        self.find_view.append_column(column)

if __name__=="__main__":
    aplicacion= ghhp()
    gtk.main()
